Problem Statement¶
Wind energy has emerged as one of the most promising renewable energy sources worldwide. However, the operation and maintenance of wind turbines are costly, especially when failures occur unexpectedly. Traditional maintenance practices either schedule repairs too frequently (leading to unnecessary costs) or too late (resulting in catastrophic breakdowns and replacements).
ReneWind aims to leverage machine learning and predictive maintenance to accurately identify potential generator failures in wind turbines. By analyzing sensor data, the company seeks to predict failures before they happen, thereby reducing downtime, minimizing costs, and improving operational efficiency.
Objective¶
- The primary objective is to develop, tune and evaluate models that can:
- Accurately predict wind turbine generator failures (failures = 1, no failures = 0).
- Maximize detection of true failures (high recall) while minimizing false alarms (high precision).
- Support predictive maintenance by ensuring components are repaired before breakdowns.
- Reduce overall operation and maintenance costs by minimizing:
- Replacement costs (from missed failures - false negatives).
- Repair costs (from correctly predicted failures - true positives). Inspection costs (from false alarms - false positives).
- Provide a scalable and reliable framework that can be integrated into real-time turbine monitoring systems.
Data Dictionary¶
The data provided is a transformed version of the original data which was collected using sensors.
- Train.csv - To be used for training and tuning of models (20,000 observations).
- Test.csv - To be used only for testing the performance of the final best model (5,000 observations).
Both datasets consist of 40 predictor variables and 1 target variable.
- Target Variable:
- 0 - No Failure (turbine operates normally).
- 1 - Failure (turbine experiences a generator failure).
Importing necessary libraries¶
In [69]:
# importing core libraries for data manipulation and visualisation
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
# importing scikit-learn utilities for preprocessing, model building and evaluation
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score, f1_score, roc_auc_score, precision_score, recall_score
from sklearn.utils.class_weight import compute_class_weight
# to oversample and undersample data
from imblearn.over_sampling import SMOTE
from imblearn.over_sampling import RandomOverSampler
from imblearn.under_sampling import RandomUnderSampler
# importing tensorflow utilities
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, BatchNormalization
from tensorflow.keras.optimizers import SGD, Adam
from tensorflow.keras.callbacks import EarlyStopping
import warnings
warnings.filterwarnings("ignore")
Loading the data¶
In [70]:
from google.colab import drive
drive.mount('/content/drive')
In [71]:
# loading data into a pandas dataframe
df_train = pd.read_csv("/content/drive/MyDrive/GL_Project/ReneWind/Train.csv")
df_test = pd.read_csv("/content/drive/MyDrive/GL_Project/ReneWind/Test.csv")
In [72]:
# creating copy of the data
df_train_copy = df_train.copy()
df_test_copy = df_test.copy()
Data overview¶
In [73]:
# displaying first 5 rows of the train data
df_train.head(5)
Out[73]:
Observation:
The first 5 rows of the train data along with the title of the column has been displayed here.
In [74]:
# displaying first 5 rows of the test data
df_test.head(5)
Out[74]:
Observation:
The first 5 rows of the test data along with the title of the column has been displayed here.
In [75]:
# checking the shape of the train data
df_train.shape
Out[75]:
Observation:
The data.shape is used to generate the number of rows and columns. Here, the train dataset has 20000 rows and 41 columns.
In [76]:
# checking the shape of the test data
df_test.shape
Out[76]:
Observation:
The data.shape is used to generate the number of rows and columns. Here, the train dataset has 50000 rows and 41 columns.
In [77]:
# checking the attribute types of the train data
df_train.info()
Observation:
- There is 1 column with integer (int64) values (Target).
- There are 40 columns with float (float64) value.
In [78]:
# checking the attribute types of the test data
df_test.info()
Observation:
- There is 1 column with integer (int64) values (Target).
- There are 40 columns with float (float64) value.
Univariate Analysis¶
In [79]:
# countplot for target variable distribution
sns.countplot(x = 'Target', data = df_train, palette = 'Set2')
plt.title('Distribution of Target Variable')
plt.show()
Observation:
The plot shows high imbalance in the data:
* Class 0 (No failures) has around 19000 samples. * Class 1 (Failures) has around 2000 samples.The ratio seems to be 90:10 with the Class 1 as minority class.
In [80]:
# univariate analysis
target_col = 'Target'
features = [col for col in df_train.columns if col != target_col] # to seprate features
for col in features:
plt.figure(figsize=(14,4))
# histogram
plt.subplot(1,3,1)
sns.distplot(df_train[col], kde=True, bins=30, color='red')
plt.title(f'Histogram distribution of {col}')
# kde
plt.subplot(1,3,2)
sns.kdeplot(df_train[col], shade=True, color='skyblue')
plt.title(f'KDE distribution of {col}')
# boxplot
plt.subplot(1,3,3)
sns.boxplot(y=df_train[col], color='lightgreen')
plt.title(f'Boxplot distribution of {col}')
plt.show()
Observation:
- The histogram seems to have a normal distribution with very few values beyond +10/-10.
- The KDE distribution is symmetric and has its distribution close to Gaussian.
- The strong density of the KDE distribution shows that the graph is normally distributed without strong skewness.
- The box plot shows that the meadian is 0 and the interquartile range (IQR) is between -2 to 2.
- Also, the box plot shows that the outliers exists but are sparse.
In [81]:
# bivariate analysis
for col in features:
plt.figure(figsize=(12,4))
# boxplot
plt.subplot(1,2,1)
sns.boxplot(x='Target', y=col, data=df_train, palette='Set2')
plt.title(f'Boxplot distribution of {col} vs Target')
# violin plot
plt.subplot(1,2,2)
sns.violinplot(x='Target', y=col, data=df_train, palette='muted')
plt.title(f'Violin plot distribution of {col} vs Target')
# heatmap
plt.figure(figsize=(15,10))
sns.heatmap(df_train.corr(), annot=True, cmap='coolwarm')
plt.title('Correlation Heatmap')
# pairplot
ss = features[:5] + [target_col]
sns.pairplot(df_train[ss], hue='Target')
plt.title('Pairplot of Features')
plt.show()
Observation:
- The box plot and violin plot for the V40 vs Target distribution shows that there is no strong sepration between the two Target classes.
- The density in violin plot is high around values close to zero for both the classes.
- In heatmap, the strong correlations (~ +1) appears in red while the strong negative correlations (~ -1) appears in blue.
- Also, heatmap shows that the features are not strongly correlated with the target; some are highly correlated with each other.
- The pairplot shows that the diagonal plots are roughly symmetric and has Gaussian distribution.
- In pairplot, the orange points (Target = 1) are less frequent and also the overall classes are overlapping a lot.
Data Preprocessing¶
In [82]:
# checking statistcal summary of train data
df_train.describe()
Out[82]:
Observation:
The train data has minimum feature value is around -3.42 while the maximum feature value is around 23.63.
In [83]:
# checking statistcal summary of test data
df_test.describe()
Out[83]:
Observation:
The test data has minimum feature value is around -17.24 while the maximum feature value is around 26.53.
In [84]:
# identifying target and features
X = df_train.drop('Target', axis=1)
y = df_train['Target'].copy()
X_test = df_test.drop(['Target'], axis=1)
y_test = df_test['Target'].copy()
In [85]:
# splitting data into train and validation to preprocess it
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)
print(f"X_train shape: {X_train.shape}")
print(f"y_train shape: {y_train.shape}")
print(f"X_val shape: {X_val.shape}")
print(f"y_val shape: {y_val.shape}")
print(f"X_test shape: {X_test.shape}")
print(f"y_test shape: {y_test.shape}")
Observation:
- The train data has 16000 samples and 40 features.
- The validation data has 4000 samples and 40 features.
- The test data has 5000 samples and 40 features.
In [86]:
# creating an instace of the imputer to be used
imputer = SimpleImputer(strategy="median")
In [87]:
# fit and transform the train data
X_train = pd.DataFrame(imputer.fit_transform(X_train), columns=X_train.columns)
# Transform the validation data
X_val = pd.DataFrame(imputer.transform(X_val), columns=X_train.columns)
# Transform the test data
X_test = pd.DataFrame(imputer.transform(X_test), columns=X_train.columns)
In [88]:
# checking missing values
print(f"Missing values in X_train:\n{X_train.isnull().sum()}")
print(f"\nMissing values in X_val:\n{X_val.isnull().sum()}")
print(f"\nMissing values in X_test:\n{X_test.isnull().sum()}")
Observation:
There are no missing values in the given dataset of ReneWind.
In [89]:
# checking for duplicate values
df_train.duplicated().sum()
Out[89]:
Observation:
There are no duplicate values in the given dataset of ReneWind.
In [90]:
# checking for outliers
for col in features[:5]:
plt.figure(figsize=(6,4))
sns.boxplot(x=df_train[col], color='lightgreen')
plt.title(f'Boxplot distribution of {col}')
plt.show()
out_sum = {}
for col in features:
if pd.api.types.is_numeric_dtype(df_train[col]): # only numeric features
Q1 = df_train[col].quantile(0.25)
Q3 = df_train[col].quantile(0.75)
IQR = Q3 - Q1
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR
outliers = ((df_train[col] < lower_bound) | (df_train[col] > upper_bound)).sum()
out_sum[col] = outliers
Observation:
- The distribution of features shows that the given features has outliers.
- V1 and V3 seems to be right-skewed as more extreme values are on the positive side.
- V2 and V5 distribution seems to be symmetric with balanced outliers.
- V4 is left-skewed has it has more negative outliers.
Model Building¶
In [91]:
# adding scale features
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_val_scaled = scaler.transform(X_val)
X_test_scaled = scaler.transform(X_test)
Model evaluation criterion¶
The nature of predictions made by the classification model will translate as follows:
- True positives (TP) are failures correctly predicted by the model. These will result in repair costs.
- False negatives (FN) are real failures where there is no detection by the model. These will result in replacement costs.
- False positives (FP) are detections where there is no failure. These will result in inspection costs.
In [92]:
# model evaluation
def evaluate_model(model, X, y, set_name="Set"):
X = np.array(X)
y = np.array(y)
prob = model.predict(X).ravel()
preds = (prob > 0.5).astype(int)
acc = accuracy_score(y, preds)
f1 = f1_score(y, preds)
roc = roc_auc_score(y, preds)
prec = precision_score(y, preds)
rec = recall_score(y, preds)
# try/except for ROC curve
try:
roc = roc_auc_score(y, prob)
except Exception:
roc = roc_auc_score(y, preds)
print(f"\tEvaluation on {set_name}\n")
print(f"Accuracy : {acc:.4f}")
print(f"F1 Score : {f1:.4f}")
print(f"ROC AUC Score : {roc:.4f}")
print(f"Precision : {prec:.4f}")
print(f"Recall : {rec:.4f}")
print("\nConfusion Matrix:\n", confusion_matrix(y, preds))
print("\nClassification Report:\n", classification_report(y, preds))
return {"accuracy": acc, "f1": f1, "roc_auc": roc, "precision": prec, "recall": rec}
Model Performance Improvement and Final Model Selection¶
In [93]:
# computing class weights for imbalance
class_weights_arr = compute_class_weight('balanced', classes=np.unique(y_train), y=y_train)
class_weights = {i: w for i, w in enumerate(class_weights_arr)}
print("Class weights:", class_weights)
In [94]:
# building model
def build_model(layers, optimizer, dropout_rate=0.0, X_tr=None, y_tr=None, X_val=None, y_val=None, use_class_weights=False, epochs=50, batch_size=64, verbose=1):
modell = Sequential()
# input layer
modell.add(Dense(layers[0], activation='relu', input_dim = X_tr.shape[1]))
# hidden layer
for size in layers[1:]:
modell.add(Dense(size, activation='relu'))
if dropout_rate > 0:
modell.add(Dropout(dropout_rate))
modell.add(Dense(1, activation='sigmoid')) # output layer
modell.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['accuracy']) # compiling model
# callbacks
es = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)
print(f"\nTraining model: layers={layers}, optimizer={type(optimizer.name).__name__}, dropout={dropout_rate}, class_weights={use_class_weights}")
hist = modell.fit(X_tr, y_tr,
epochs=epochs, batch_size=64,
validation_data=(X_val, y_val),
verbose=verbose,
class_weight = class_weights if use_class_weights else None)
# evaluating model
ev_tr = evaluate_model(modell, X_tr, y_tr, set_name="Training")
ev_va = evaluate_model(modell, X_val, y_val, set_name="Validation")
return modell, hist
In [95]:
# model 1: baseline - shallow NN + SGD
m1, h1 = build_model([32, 16], SGD(learning_rate=0.01),
dropout_rate=0.0, X_tr=X_train_scaled, y_tr = y_train.values,
X_val = X_val_scaled, y_val = y_val.values,
use_class_weights=False, epochs=50, batch_size=64, verbose=1)
Observation:
- This model has a better performance on the training and validation datasets with high accuracy values (0.989 on training and 0.988 on validation) and precision values (0.979 on training and 0.973 on validation).
- The recall for class 1 is lower than that of class 0 and indicates that the model is good at predicting the majority class.
- The f1-score for class 0 is higher than that of class 1 (0.99 on class 0 and 0.89 on class 1).
In [96]:
# model 2: Deeper NN + SGD
m2, h2 = build_model([64, 32, 16], SGD(learning_rate=0.01),
dropout_rate=0.1, X_tr=X_train_scaled, y_tr = y_train.values,
X_val = X_val_scaled, y_val = y_val.values,
use_class_weights=False, epochs=50, batch_size=64, verbose=1)
Observation:
- This model has a better performance on the training and validation datasets with high accuracy values (0.991 on training and 0.992 on validation) and precision values (0.985 on training and 0.980 on validation).
- The recall for class 1 is lower than that of class 0 and indicates that the model is good at predicting the majority class.
- The f1-score for class 0 is higher than that of class 1 (0.99 on class 0 and 0.89 on class 1) and indicates that the model is better than the previous evaluation.
In [97]:
# model 3: NN + Adam Optimizer
m3, h3 = build_model([32, 16], SGD(learning_rate=0.001),
dropout_rate=0.0, X_tr=X_train_scaled, y_tr = y_train.values,
X_val = X_val_scaled, y_val = y_val.values,
use_class_weights=False, epochs=50, batch_size=64, verbose=1)
Observation:
- This model has a better performance on the training and validation datasets with high accuracy values (0.968 on training and 0.970 on validation) and precision values (0.937 on training and 0.981 on validation).
- The recall values for both the training and the validation is very low which thus indicates that the model is heavily biased towards the majority class (class 0).
- The f1-score for class 0 is much higher than that of class 1 (0.98 on class 0 and 0.64 on class 1) and indicates that the model is missing more than half of the minority instances.
In [98]:
# model 4: NN + Adam + Dropout
m4, h4 = build_model([64, 32], SGD(learning_rate=0.001),
dropout_rate=0.3, X_tr=X_train_scaled, y_tr = y_train.values,
X_val = X_val_scaled, y_val = y_val.values,
use_class_weights=False, epochs=50, batch_size=64, verbose=1)
Observation:
- This model has a better performance on the training and validation datasets with high accuracy values (0.966 on training and 0.963 on validation) and high precision values (0.985 on training and 0.975 on validation).
- The recall values for both the training and the validation is very low (0.393 on training and 0.355 on validation) which thus indicates that it is much lower for the the minority class.
- The f1-score for class 0 is much higher than that of class 1 (0.56 on training and 0.52 on validation) and indicates that the model is missing a large portion of true positive values.
In [99]:
# model 5: NN + SGD + Class Weight
m5, h5 = build_model([32, 16], SGD(learning_rate=0.01),
dropout_rate=0.0, X_tr=X_train_scaled, y_tr = y_train.values,
X_val = X_val_scaled, y_val = y_val.values,
use_class_weights=False, epochs=50, batch_size=64, verbose=1)
Observation:
- This model has a better performance on the training and validation datasets with high accuracy values (0.989 on training and 0.989 on validation) and high precision values (0.981 on training and 0.973 on validation).
- The recall values for both the training and the validation is very low (0.825 on training and 0.828 on validation) which thus indicates that it is much lower for the the minority class.
- The f1-score for class 0 is much higher than that of class 1 (0.90) and indicates that the model is effectively detecting minority instances.
In [100]:
# model 6: Deep NN + Adam + Dropout + Class Weight
m6, h6 = build_model([128, 64, 32], Adam(learning_rate=0.001),
dropout_rate=0.4, X_tr=X_train_scaled, y_tr = y_train.values,
X_val = X_val_scaled, y_val = y_val.values,
use_class_weights=False, epochs=50, batch_size=64, verbose=1)
Observation:
- This model has a better performance on the training and validation datasets with high accuracy values (0.995 on training and 0.993 on validation) and high precision values (0.981 on training and 0.973 on validation).
- The recall values for both the training and the validation is very low (0.917 on training and 0.914 on validation) which thus indicates that it is much lower for the the minority class.
- The model has strong f1-score for class 0 is much higher than that of class 1 (0.96) and indicates that the model is effectively detecting minority instances.
Choosing the best model¶
- As per the observations from Models 1 to 6, the best model choosen is Model 6 (Deep NN + Adam + Dropout + Class Weight).
- Model 6 achieves the best balanced value for all the evaluation metrics.
- It ensures both majority and minority classes are well predicted.
- This model has the highest overall accuracy values, strong F1 score, high recall values and high precision for minority class.
- With a good ROC-AUC score, it has a strong disccriminative ability between the classes.
- The confusion matrix shows very low rates of false negatives and false positives demonstrating its reliability.
Actionable Insights & Recommendations¶
- The dataset of ReneWind is highly imbalanced (90:10 ratio) and requires resampling or class weighting to ensure that the dataset becomes balanced for both the class 0 and class 1.
- Several features have significant outliers which may affect the predictions if they are left untreated.
- The precision for all the models are high and indicates that the false positives (FP) are minimal.
- Each of the prediction could be translated as:
- True positives (TP) are failures correctly predicted by the model which will result in repair costs.* False negatives (FN) are real failures where there is no detection by the model. These will result in replacement costs.
- False positives (FP) are detections where there is no failure and will result in inspection costs.
- Among all the 6 models that were tested, the Deep Neural Network with Adam optimizer, dropout and class weights has provided the most balanced performance by achieving high accuracy.
Key Takeaways for the Business¶
- The traditional machine learning methods would likely underperform because the failure patterns are not noticeable and non-linear. Thus, deep learning model provies the best fit.
- The low correlation value of the data signalled to the turbine failures.
- The turbine replacements are expensive when compared to inspections and thus every false negative (FN) helps the company from turbine replacement.
- The model 6 (the Deep Neural Network with Adam optimizer, dropout and class weights model) provided high accuracy, recall and precision values, proving that it is reliable for deployment in operational environments.
- This predictive approach helps in predicting the failures and thus the turbines can undergo planned maintenance instead of expensive downtime and replacements.
Conclusion¶
- The dataset is anaysed and the outliers, imbalance and distribution of the features are found.
- Several neural networks were tested from baseline neural network to deep neural network and the best model is found to be the Deep Neural Network with Adam optimizer, dropout and class weights.
- This approach has reduced the false negatives and has resulted in minimizing replacement costs.
- The deep learning based prediction aligns with the cost reduction and operational efficiency goals of ReneWind.
- The predicted solution is generalizable and can be integrated to ral-time systems.
Business Recommendations¶
- The Deep Neural Network with Adam optimizer, dropout and class weights model is found to have better performance when compared to the other models and hence this model can be integrated into the turbine monitoring platform.
- The connection of temperature sensor and vibration sensor can help in feeding live data into the predictive model.
- The predictive insights can be shared to the manufacturers to develop better turbines which can be monitored easily and has reduced downtime.
- The predictive maintenance and preventive maintenance schedules can be combined to create a hybrid system to ensure that the turbines are inspected regularly.
- A dashboard can be created for the operation and maintenance managers to visualize the real-time turbine conditions to feed live data into the predictive model.